Modular Compilation of a Synchronous Language

Synchronous languages rely on formal methods to ease the development of applications in an efficient and reusable way. Formal methods have been advocated as a means of increasing the reliability of systems, especially those which are safety or business critical. It is still difficult to develop automatic specification and verification tools due to limitations like state explosion, undecidability, etc... In this work, we design a new specification model based on a reactive synchronous approach. Then, we benefit from a formal framework well suited to perform compilation and formal validation of systems. In practice, we design and implement a special purpose language (LE) and its two semantics~: the ehavioral semantics helps us to define a program by the set of its behaviors and avoid ambiguousness in programs' interpretation; the execution equational semantics allows the modular compilation of programs into software and hardware targets (c code, vhdl code, fpga synthesis, observers). Our approach is pertinent considering the two main requirements of critical realistic applications~: the modular compilation allows us to deal with large systems, the model-based approach provides us with formal validation

Algebras and Synchronous Language Semantics

In this report, we study different multi-valued algebras allowing to formally specify synchronous language semanticsCe rapport étudie différentes algèbres multi-valuées permettant de donner un cadre formel à la définition des sémantiques des langages synchrones

Algebraic Framework for Synchronous Language Semantics

International audienceIn this article, we study several relevant algebraic frameworks to define synchronous language semantics. Synchronous languages are quite dedicated to design critical embedded applications. Thus, verification and compilation is challenging and should rely on mathematical semantics. We study multi-valued algebras as foundation for semantics definition and we show that a 4-valued algebra with a bilattice structure is well suited to our concern. With this approach we can define semantics offering both the generation of models where verification techniques apply, and separated compilation means.Cet article étudie différents cadres algébriques adéquats pour définir les sémantiques des languages synchrones. Ces languages sont principalement dédiés à la conception de systèmes crtiques embarqués. Leur vérification et leur compilation sont des challenges importants et doivent s'appuyer sur des sémantiques bien fondées mathématiquement. Dans cet article, nous étudions les algèbres multi valuées et nous montrons qu'une algèbre particulière, 4-valuée avec une structure de bilattice répond à notre problème. Cette approche nous permet de définir une sémantique permettant l'application des techniques de vérification formelle et offrant la possibilité d'une compilation séparée

The FCTOOLS User Manual (Version 1.0)

We describe a set of modular extensions to our Auto/Graph verification toolset for networks of communicating processes. These software additions operate from a common file exchange format for automata and networks, called {\sc fc2}. Tool functionalities comprise graphical depiction of objects, global model construction from hierarchical descriptions, various types of model reductions and of verification of simple modal properties by observers, counterexample production and visualisation. We illustrate typical verification sessions conducted on usual academic examples: dining philosophers, mutual exclusion algorithms and round-robin schedulers. Based on previous experience of drastic state explosion problems we aim here at efficiency in implementation. We use both explicit representation techniques and implicit techniques such as {\sc BDD}s, with functional overlap at places

Compilation Modulaire d'un Langage Synchrone

National audienceIn this paper, we study the modular compilation of imperative synchronous programs. We rely on a formal framework well suited to perform compilation and formal validation of systems. In practice, we design and implement a special purpose language (LE) and its \execution equational semantics that allows the modular compilation of programs into software and hardware targets (C code, Vhdl code, FPGA synthesis, Verification tools). We show the correctness of this semantics, and we introduce a new algorithm to check program causality with respect to our modular approach. Relying in this formal approach, we defined a toolkit dedicated to the compilation and the verification of reactive applications.Dans cet article, nous étudions la compilation modulaire de programmes synchrones impératifs. Nous nous appuyons sur des méthodes formelles pour compiler et valider les applications spécifiées. Nous avons défini et implémenté un langage dédié (LE) et sa sémantique équationnelle qui permet la compilation modulaire des programmes vers différentes cibles logicielles et matérielles (code C, code Vhdl, synthétiseurs fpga, format d'entr\ée d'outils de vérification, ...). Nous montrons que cette sémantique est correcte et nous introduisons un algorithme pour vérifier la causalité qui respecte notre approche modulaire. En nous appuyant sur cette approche formelle, nous avons réalisé une boite à outils pour compiler et vérifier des applications réactives synchrones

Études et développement de diagrammes de décision linéaires

National audienceModel verification, more commonly known as Model Checking, is a concept basedon an automatic formal verification approach of temporal properties on reactive systems.INRIA in collaboration with LEAT developed CLEM, a modeling and propertyverification tool, based on a state representation in finite automata generated automaticallyusing binary decisions diagrams. From an evolutionary point of view, thework carried out during this internship was to develop the library of linear decisionsdiagrams, we focused on the implementation of new reduction methods in cases of"Imply High" and "Imply Low" case. The objective of this work is to develop theverification part of CLEM by replacing the representation of the fundamental valuesusing binary decisions diagrams(BDDs) with linear decisions diagrams(LDDs) whichwill allow us to represent the states by integer values instead of signals which arenot comparable among themselves. This new library, once implemented on CLEM,will make checks of finer models and, we hope, will make it more powerful.La vérification de modèle, plus communément appelé Model Checking, est un conceptbasé sur une approche automatique de vérification formelles des propriétés temporellessur des systèmes réactifs. INRIA en collaboration avec le LEAT ont développéCLEM, un outil de modélisation et de vérification de propriétés, s’appuyant sur unereprésentation d’état en automates finis générés automatiquement et représentés pardes Diagrammes de Décisions Binaires. Dans une optique d’évolution, le travaileffectué durant ce stage a été de développer la bibliothèque de diagramme de décisionlinéaire, nous nous sommes concentrés sur l’inclusion de nouvelles méthodes deréduction dans les cas d’implication forte et faible. L’objectif de ce travail est de développerla partie vérification de CLEM en remplaçant la représentation actuelle desvaleurs fondamentales qui utilisent des diagrammes de décisions binaires(BDDs) parles diagrammes de décisions linéaires(LDDs) ce qui nous permettrait de représenterles états par des valeurs entières et non par des signaux non comparables entre eux.Cette nouvelle bibliothèque de LDDs, une fois implémentée sur CLEM, permettrade faire des vérifications de modèles plus fines et, potentiellement, le rendra plusperformant

Application de CEYX à la construction de programmes sous forme de machines virtuelles

Disponible dans les fichiers attachés à ce documen

Composition and Formal Validation in Reactive Adaptive Middleware

Nowadays, adaptive middleware plays an important role in the design of applications in ubiquitous and ambient computing. Currently most of these systems manage the adaptation at the middleware intermediary layer. Dynamic adaptive middleware are then decomposed into two levels : a first one to simplify the development of distributed systems using devices, a second one to perform dynamic adaptations within the first level. In this report we consider component-based middleware and a corresponding compositional adaptation. Indeed, the composition often involves conflicts between concurrent adaptations. Thus we study how to maintain consistency of the application in spite of changes of critical components and conflicts that may appear when we compose some component assemblies. Relying on formal methods, we provide a well defined representation of component behaviors. In such a setting, model checking techniques are applied to ensure that concurrent access does not violate expected and acceptable behaviors of critical components.De nos jours, les middlewares adaptatifs et réactifs jouent un role important dans la conception d'applications dans le domaine de l'Informatique ubiquitaire et ambiante. Généralement, ces systèmes réalisent cette adaptation au niveau intermédiaire du middleware. Ainsi, les middlewares adaptatifs sont décomposés en deux parties: une première partie qui permet un développement simplifié des systèmes distribués utilisant des dispositifs, une seconde qui réalise les adaptations dynamiques de la première partie. Dans ce rapport nous considérons des middlewares à base de composants et une adapaptation compositionnelle. Mais souvent lors d'une composition certaines adaptations concurrentes s'avèrent conflictuelles. Pour résoudre ce problème, nous étudions comment préserver la consistence d'une application lors de changements concernant certains composants critiques, avec des conflits qui peuvent apparaitre quand on compose des assemblages de composants. Nous utilisons des méthodes formelles pour modéliser le comportement des composants afin de bénéficier des techniques de vérification par model checking et ainsi prouver que des accès concurrents respectent les comportements acceptables des composants critiques

Towards Formalizing Behavorial Substitutability in Component Frameworks

International audienceWhen using a component framework, developers need to respect the behavior implemented by the components. Static information about the component interface is not sufficient. Dynamic information such as the description of valid sequences of operations is required. In this paper we propose a mathematical model and a formal language to describe the knowledge about behavior. We rely on a hierarchical model of deterministic finite state-machines. The execution model of these state-machines follows the Synchronous Paradigm. We focus on extension of components, owing to the notion of behavioral substitutability. A formal semantics for the language is defined and a composition-ality result allows us to get modular model-checking facilities. From the language and the model, we can draw practical design rules that are sufficient to preserve behavorial substitutability. Associated tools may ensure correct (re)use of components, as well as automatic simulation and verification , code generation, and run-time checks

BLOCKS, a Component Framework with Checking Facilities for Knowledge-Based Systems

équipe PULSARInternational audienceBLOCKS is an answer to the software engineering needs of the design of knowledge-based system engines. It is a framework composed of reusable and adaptable software components. However , its safe and correct use is complex and we supply formal models and associated tools to assist using it. These models and tools are based on behavioral description of components and on model checking techniques. They ensure a safe reuse of the components, especially when extending them through inheritance, owing to the notion of behavioral refinement